1
00:00:02,560 --> 00:00:07,140
अब, हमने अपने कस्टम हुक के साथ काम करना शुरू कर दिया है, अब इसका मतलब है कि हम इस घटक को साफ कर सकते हैं

2
00:00:07,140 --> 00:00:11,700
थोड़ा सा, हमारे पास पहले से मौजूद कुछ कोड हटा दें, मूल रूप से वह सब कुछ जो हमने वहां टिप्पणी की थी।

3
00:00:12,240 --> 00:00:16,610
अब ADD घटक हैंडलर के लिए, आप यह भी देखेंगे कि हमें यहां एक चेतावनी मिल रही है।

4
00:00:16,650 --> 00:00:21,330
कुछ हरी टेढ़ी-मेढ़ी रेखाएँ हैं जो हमें याद आ रही हैं, एक निर्भरता अनुरोध भेजें।

5
00:00:21,330 --> 00:00:23,730
और वास्तव में, हमें इसे यहां जोड़ना चाहिए।

6
00:00:24,570 --> 00:00:30,000
अब, घटक हैंडलर जोड़ें, रीन हैंडलर को हटाने के समान ही अनुरोध भेजें, शुक्र है कि लपेटा गया है

7
00:00:30,000 --> 00:00:33,720
और यहां हमारे कस्टम हुक में कॉलबैक का उपयोग करें।

8
00:00:33,840 --> 00:00:39,690
और इसलिए इसका पुनर्निर्माण नहीं किया जाएगा या घटक के प्रत्येक पुनर्निर्माण के लिए इसे दोबारा नहीं बनाया जाएगा

9
00:00:39,690 --> 00:00:42,180
इसलिए घटक हैंडलर को हटा दें, जिसका उपयोग सभी उपयोगकर्ता करते हैं।

10
00:00:42,180 --> 00:00:47,010
कॉलबैक दोबारा नहीं बनाया गया है और इसलिए चाइल्ड घटकों का हमारा अनुकूलन बरकरार रहता है।

11
00:00:47,700 --> 00:00:51,300
और हम त्रुटियों को संभाल नहीं रहे थे या त्रुटियों को दूर नहीं कर रहे थे।

12
00:00:51,300 --> 00:00:52,500
यह कोई ऐसी चीज़ नहीं है जो हम कर रहे हैं।

13
00:00:53,130 --> 00:00:56,400
हम अपने रीति-रिवाज की मदद से यहां भी ऐसा करना चाहते हैं।'

14
00:00:58,130 --> 00:01:03,950
अब, अगर हमें कोई त्रुटि मिल रही है तो हम यहां एक त्रुटि सेट कर रहे हैं, लेकिन हमारे पास इसे साफ़ करने का कोई तरीका नहीं है, मैं वास्तव में ऐसा करूंगा

15
00:01:03,950 --> 00:01:09,740
मेरे निर्माता में मेरी कस्टम बुक में एक नया मामला दर्ज करें, जिसका नाम क्लियर होगा, और मैं वहां वापस आऊंगा

16
00:01:09,740 --> 00:01:10,610
एक नई वस्तु.

17
00:01:11,000 --> 00:01:15,050
और अनिवार्य रूप से मैं वहां जो करता हूं वह यह है कि मैं बस इस नई प्रारंभिक स्थिति को वापस कर दूंगा।

18
00:01:15,410 --> 00:01:18,710
तो मैं इसे यहां काट दूंगा, वहां एक नया स्थिरांक बनाऊंगा।

19
00:01:21,040 --> 00:01:26,680
हो सकता है कि आरंभिक अवस्था के रूप में नामित किया गया नाम एक उपयुक्त नाम की तरह लगता है, और वह बिल्कुल वस्तु के रूप में है, और फिर यहाँ है

20
00:01:26,680 --> 00:01:32,170
एक स्पष्ट मामले में, मैं बस इस प्रारंभिक स्थिति ऑब्जेक्ट को ऊपर से लौटाता हूं, और यह वही प्रारंभिक स्थिति है

21
00:01:32,170 --> 00:01:35,080
ऑब्जेक्ट जिसे हम रिड्यूसर को इनिशियलाइज़ करने के लिए उपयोग कर सकते हैं।

22
00:01:38,590 --> 00:01:40,570
और हमें यहां घुंघराले ब्रेसिज़ की आवश्यकता नहीं है।

23
00:01:41,630 --> 00:01:49,040
और इसलिए, हम उस पुराने स्पष्ट मामले से छुटकारा पा सकते हैं, नया वह रीसेट करता है जिसे हम अब स्पष्ट करना चाहते हैं

24
00:01:49,460 --> 00:01:50,630
कुछ हम है.

25
00:01:51,980 --> 00:01:57,320
प्रेषण कर सकते हैं, लेकिन हम इसे कभी भी यहां कहीं भी नहीं भेज रहे हैं, इसलिए हम यहां एक नया फ़ंक्शन बनाएंगे

26
00:01:57,320 --> 00:02:00,140
मेरे कस्टम हुक के अंदर साफ़।

27
00:02:01,360 --> 00:02:06,700
या आप इसे जो भी नाम देना चाहें, यह एक बहुत ही सरल फ़ंक्शन है जो डिस्पैच, एचटीपी और का उपयोग करता है

28
00:02:06,700 --> 00:02:09,880
डिस्पैच, यह एक क्रिया है जहां सिंपलिस्ट क्लियर टाइप करना है।

29
00:02:10,030 --> 00:02:12,240
कोई डेटा जोड़ने की आवश्यकता नहीं है, ऐसा कुछ भी नहीं है।

30
00:02:12,920 --> 00:02:16,800
मैं रेंडर किए गए डिस्केट से बचने के लिए यहां कॉलबैक का उपयोग भी करूंगा।

31
00:02:17,080 --> 00:02:18,610
हमें कोई बाहरी निर्भरता नहीं मिली।

32
00:02:18,610 --> 00:02:23,590
तो क्या यह एक खाली सरणी है और अब क्लियर एक फ़ंक्शन है जिसे आप हमेशा यहां वापस कर सकते हैं।

33
00:02:24,630 --> 00:02:31,070
तो मैं हमारे कस्टम हुक से समग्र रूप से लौटते हुए उस ऑब्जेक्ट में एक मुख्य मान युग्म के रूप में क्लियर वापस आऊंगा।

34
00:02:32,020 --> 00:02:33,340
हमारे में हमारे घटक में.

35
00:02:34,520 --> 00:02:36,230
हम स्पष्ट तक पहुंच प्राप्त कर सकते हैं।

36
00:02:37,870 --> 00:02:45,790
बस इसे और साथ ही हमारे उपयोग HTP परिणाम से एक संपत्ति को निकालकर, इसलिए हमारे कस्टम हुक से और

37
00:02:45,790 --> 00:02:52,780
अब नीचे साफ हवा में, हमें बस इतना करना है कि हम साफ हवा को इस तरह कहें या हम साफ हवा से छुटकारा पा लें

38
00:02:52,780 --> 00:02:53,830
यहाँ पूरी तरह से हवा.

39
00:02:54,220 --> 00:03:00,310
और नीचे आर्मोरेल के कपड़ों पर, हम बस स्पष्ट की ओर इशारा करते हैं, जो कि निकाला गया फ़ंक्शन है

40
00:03:00,310 --> 00:03:03,730
हम अपने कस्टम हुक से प्राप्त कर रहे हैं, जो पहले से ही उपयोग कॉलबैक में लिपटा हुआ है।

41
00:03:05,210 --> 00:03:12,050
तो अब आइए परीक्षण करें कि क्या यह फिर से लीड हैंडलर के पास जाकर एस्सेरे को हटाकर काम करता है

42
00:03:12,050 --> 00:03:14,300
किसी त्रुटि लॉग इन को बाध्य करने के लिए।

43
00:03:15,340 --> 00:03:16,400
केले पर क्लिक करें.

44
00:03:17,020 --> 00:03:22,140
यह अच्छा लग रहा है, हम इसे संभाल सकते हैं, हम उम्मीद करते हैं कि अभी भी नए सेब जोड़ सकते हैं।

45
00:03:22,150 --> 00:03:23,260
तो यह सब काम कर रहा है।

46
00:03:23,680 --> 00:03:27,520
यदि मैं त्रुटि ठीक कर दूं, तो निस्संदेह, हटाने से सारा काम फिर से हो जाएगा।

47
00:03:27,880 --> 00:03:30,720
इसलिए यदि मैं अपने सेब हटा दूं, तो यह अच्छा लगेगा।

48
00:03:31,450 --> 00:03:36,640
तो अब हम यहां अपने स्थान पर कस्टम हुक का उपयोग कर रहे हैं, जहां हम निश्चित रूप से, इसे खोज के रूप में उपयोग कर सकते हैं

49
00:03:36,640 --> 00:03:37,150
घटक.

50
00:03:38,430 --> 00:03:44,430
खोज घटक में, हम HTP अनुरोध भी भेज रहे हैं, इसलिए टू हुक का उपयोग न करने का कोई कारण नहीं है

51
00:03:44,430 --> 00:03:48,480
इसे यहां उपयोग करने का साहस करें, मैं निश्चित रूप से इसे आयात करूंगा।

52
00:03:48,480 --> 00:03:50,250
से HTP का प्रयोग करें.

53
00:03:52,520 --> 00:04:00,590
हुक्स, एचटीपी जैस और फिर कॉल से पहले न्याय, वहां एचटीपी का उपयोग करें और फिर वहां से कुछ डेटा निकालें,

54
00:04:00,620 --> 00:04:04,310
जिसमें अब हमारी रुचि है, वह पहले की तुलना में कम डेटा हो सकता है।

55
00:04:04,340 --> 00:04:05,840
मैं इसे यहां थोड़ा सरल रखूंगा।

56
00:04:06,080 --> 00:04:07,450
मुझे लोड करने में दिलचस्पी है.

57
00:04:07,460 --> 00:04:09,520
मुझे डेटा में दिलचस्पी है, दिलचस्प हैं।

58
00:04:09,560 --> 00:04:10,670
संभावित त्रुटियाँ.

59
00:04:11,800 --> 00:04:16,260
और मैं अपने अनुरोध भेजने में सक्षम होना चाहता हूं क्योंकि मैं त्रुटियों को संभालता हूं, मुझे फ़ंक्शन साफ़ करने की भी आवश्यकता है।

60
00:04:17,050 --> 00:04:21,010
और अब वह सब निकालने के बाद, हम यहां अनुरोध भेजना चाहते हैं।

61
00:04:22,060 --> 00:04:25,210
जहां हमने पहले फ़ेच कहा था, सो कॉल करें।

62
00:04:26,170 --> 00:04:33,010
यहां अनुरोध भेजें और मेरे आप एलास हैं, निश्चित रूप से, वही चीज़ जो मेरे पास पहले थी, इसलिए आप असहाय हैं

63
00:04:33,010 --> 00:04:39,010
यहां क्वेरी विधि अनुरोध प्राप्त करने के लिए है, हमें किसी निकाय की आवश्यकता नहीं है, हमें किसी अतिरिक्त अनुरोध की आवश्यकता नहीं है।

64
00:04:39,040 --> 00:04:43,420
हमें यह भी पहचानने की आवश्यकता है क्योंकि इस घटक में, यह एकमात्र अनुरोध है जिसे हम भेज रहे हैं।

65
00:04:43,420 --> 00:04:48,940
इसलिए हम इसे हमेशा पहचानने में सक्षम रहेंगे और इसलिए हम यहां उस सभी तर्क से छुटकारा पा सकते हैं।

66
00:04:49,120 --> 00:04:52,720
मैं उस परिवर्तन तर्क को बनाए रखूंगा क्योंकि हमें एक सेकंड में इसकी आवश्यकता होगी।

67
00:04:54,440 --> 00:04:56,900
और मैं बस इस साल कटौती करूंगा।

68
00:04:58,140 --> 00:05:04,410
तो अभी, अभी के लिए, मैं यहां केवल अनुरोध भेज रहा हूं, यदि हम तय करते हैं कि अब संभालने का समय आ गया है

69
00:05:04,410 --> 00:05:07,260
प्रतिक्रिया और फिर कभी उपयोग न करने वाले प्रभाव कॉल का उपयोग करें।

70
00:05:09,070 --> 00:05:12,460
वैसे, प्रभाव कॉल का उपयोग करने का क्रम निर्धारित करना यहां कोई मायने नहीं रखता।

71
00:05:13,770 --> 00:05:21,870
और यह, निश्चित रूप से, जब भी हमें डेटा मिले तब निष्पादित होना चाहिए, लेकिन यह लोडिंग पर भी निर्भर करेगा

72
00:05:21,870 --> 00:05:24,840
एक त्रुटि पर क्योंकि यहाँ पर।

73
00:05:26,560 --> 00:05:35,680
मैं यह जांचना चाहता हूं कि क्या हम लोड नहीं कर रहे हैं और हमें कोई त्रुटि नहीं है और हमारे पास डेटा है, मान लीजिए, फिर यदि ऐसा है

74
00:05:35,680 --> 00:05:37,720
मामला, तो हम जानते हैं कि हमें कुछ डेटा वापस मिल गया है।

75
00:05:38,720 --> 00:05:44,900
हेरा अब इस परिवर्तन तर्क प्रतिक्रिया डेटा को जोड़ेगी जो अब केवल वह डेटा है जो हमें वापस मिला है इसलिए हम ऐसा कर सकते हैं

76
00:05:44,900 --> 00:05:49,430
बस प्रतिक्रिया डेटा को डेटा से बदलें और फिर हम ऑनलोड सामग्री को कॉल करते हैं।

77
00:05:50,640 --> 00:05:55,140
अब, सभी लोडिंग, पुनः स्थापित करना, निश्चित रूप से, यहां पर भी निर्भरता है।

78
00:05:56,180 --> 00:05:57,590
सामग्री लोड करें.

79
00:05:57,830 --> 00:06:00,530
हमें बस इतनी ही निर्भरता जोड़ने की आवश्यकता है क्योंकि हम इसे यहां बुला रहे हैं।

80
00:06:02,940 --> 00:06:09,360
अब, तथ्य के पहले प्रयोग में, यहां कॉल करें, हम दर्ज किए गए फेल्टर पर निर्भर हैं, हम रेफरी पर निर्भर हैं,

81
00:06:09,360 --> 00:06:15,660
निःसंदेह हम अब अधिक सामग्री पर निर्भर नहीं हैं, बल्कि इसके बजाय अब हमारे पास एक नई निर्भरता है, जो है

82
00:06:15,660 --> 00:06:16,460
अनुरोध भेजे गए.

83
00:06:16,460 --> 00:06:21,060
इसलिए हमें इसे जोड़ना चाहिए क्योंकि हम यहां इस फ़ंक्शन का उपयोग कर रहे हैं और फ़ंक्शन सामान्य निर्भरताएं हैं,

84
00:06:21,060 --> 00:06:22,140
बिल्कुल हमारे मूल्यों की तरह.

85
00:06:22,500 --> 00:06:27,810
हालाँकि, यह हमारे कस्टम हुक में उपयोग कॉलबैक में लिपटा हुआ है, यह किसी अन्य कॉल को ट्रिगर नहीं करेगा

86
00:06:27,960 --> 00:06:28,650
तथ्य का उपयोग.

87
00:06:28,650 --> 00:06:30,300
और बिलकुल ऐसा ही होना चाहिए.

88
00:06:31,570 --> 00:06:32,800
तो अब, आखिरी लेकिन महत्वपूर्ण बात।

89
00:06:33,830 --> 00:06:41,510
हम वह सब कर रहे हैं, आइए यहां पिताजी, सभी आयात, डीलर या मोडल के लिए त्रुटि प्रबंधन भी न जोड़ें।

90
00:06:42,680 --> 00:06:49,580
यूआई एरर मोटल से और अगर मैं अब जेज़ेफ़ अनुभाग पर जाता हूं, तो आप उस कार्ड से ऊपर हैं।

91
00:06:49,580 --> 00:06:51,320
यदि कोई त्रुटि है तो मैं उसकी जाँच करूँगा।

92
00:06:51,660 --> 00:07:00,110
यदि हमारे पास कोई त्रुटि है, तो मैं त्रुटि मॉडल प्रस्तुत करूंगा और त्रुटि मॉडल में वह बहुत अधिक एम्परसेंड होना चाहिए

93
00:07:00,110 --> 00:07:01,430
त्रुटि में संकेत.

94
00:07:01,820 --> 00:07:04,550
मैं अपनी त्रुटि आउटपुट करना चाहता हूं, जो संदेश है।

95
00:07:04,850 --> 00:07:08,980
और उस मॉडल के समापन पर मैं स्पष्ट अधिकार कहना चाहता हूं।

96
00:07:08,990 --> 00:07:13,880
यह मेरा स्पष्ट कार्य मेरे कस्टम हुक से आ रहा है, जिसे मैं यहां निकाल रहा हूं।

97
00:07:15,510 --> 00:07:21,150
तो अब यहां यह सब किया जा रहा है ताकि बीच में थोड़ा लोडिंग इंडिकेटर भी दिखाया जा सके, मान लीजिए

98
00:07:21,150 --> 00:07:26,420
भारतीय लेबल, मैं यहां लोडिंग स्पिनर नहीं जोड़ूंगा, यह वास्तव में इंटरफ़ेस को विकृत कर देगा।

99
00:07:26,790 --> 00:07:29,280
इसके बजाय, मैं बस जाँच करूँगा कि क्या लोड हो रहा है।

100
00:07:29,610 --> 00:07:35,250
और अगर ऐसा है, तो मैं वहां लोड हो रहे टेक्स्ट के साथ एक स्पैन आउटपुट करना चाहता हूं।

101
00:07:36,090 --> 00:07:42,870
यदि हम उसे सहेजते हैं और लॉग इन करते हैं, तो आप यहां एक टेक्स्ट के रूप में लोड होते हुए देखते हैं और यदि मैं यहां टाइप करता हूं तो आप इसे भी देखते हैं

102
00:07:42,880 --> 00:07:43,560
और फिर प्रतीक्षा करें.

103
00:07:46,270 --> 00:07:46,900
इस कदर।

104
00:07:47,840 --> 00:07:53,030
इसलिए, यह सही ढंग से काम करता प्रतीत होता है, और यदि हम नेटवर्क टैब की जांच करते हैं, तो हमें कोई अनंत भी नहीं दिखता है

105
00:07:53,030 --> 00:07:54,480
वहां अनुरोधों की मात्रा.

106
00:07:55,310 --> 00:07:59,750
आइए कुछ सेब जोड़ें और फिर फ़िल्टर को यहां अपडेट करें।

107
00:08:01,410 --> 00:08:08,790
तो यह सब मुझे बहुत अच्छा लग रहा है, और अब हम खोज घटक में कस्टम हुक का भी उपयोग कर रहे हैं।


